#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
MUD客户端会话连接管理模块
负责建立和管理与MUD服务器的连接会话
"""

import asyncio
import telnetlib3
import logging
from typing import Optional
from ..utils.encoding import remove_control_characters
from .protocol import MUDTelnetClient

# 如果有其他自定义客户端，也需要导入
# from .protocol import MUDTelnetExtended1, MUDTelnetExtended2

class MUDSession:
    """
    MUD会话管理器
    负责建立和管理与MUD服务器的连接会话
    """
    
    def __init__(self, host: str, port: int, encoding: str = 'utf-8', client_type: str = 'default'):
        """
        初始化会话管理器
        
        Args:
            host (str): 服务器主机地址
            port (int): 服务器端口号
            encoding (str): 字符编码，默认为utf-8
            client_type (str): 客户端类型，默认为'default'
        """
        self.host = host
        self.port = port
        self.encoding = encoding
        self.client_type = client_type
        self.logger = logging.getLogger(__name__)
        self.connected = False
        self._reader = None
        self._writer = None
    
    async def connect(self) -> bool:
        """
        连接到MUD服务器
        
        Returns:
            bool: 连接是否成功
        """
        self.logger.info(f"正在连接到 {self.host}:{self.port} (编码: {self.encoding})")
        


        # 建立telnet连接，使用指定的客户端类型
        self._reader, self._writer = await telnetlib3.open_connection(
            self.host, 
            self.port, 
            encoding=self.encoding,
            encoding_errors='ignore',
            connect_minwait=0,
            connect_maxwait=0,
            term='XTERM-256COLOR',
            cols=80,
            rows=24,
            client_factory=MUDTelnetClient,
        )
        
        self.connected = True
        self.logger.info(f"成功连接到 {self.host}:{self.port}")
        return True
            
        # except Exception as e:
        #     self.logger.error(f"连接到 {self.host}:{self.port} 失败: {e}")
        #     self.connected = False
        #     self._reader = None
        #     self._writer = None
        #     return False
    
    async def disconnect(self):
        """
        断开与服务器的连接
        """
        if self.connected and self._writer:
            try:
                self._writer.close()
                # TelnetWriter没有wait_closed方法，只有close方法
                # asyncio.StreamWriter才有wait_closed方法
                self.logger.info(f"已断开与 {self.host}:{self.port} 的连接")
            except Exception as e:
                self.logger.error(f"关闭连接时发生错误: {e}")
        
        self.connected = False
        self._reader = None
        self._writer = None
    
    async def send_data(self, data: str):
        """
        发送数据到服务器
        
        数据流处理规范的最后一环：
        由MUDClient调用，负责将数据通过网络发送到服务器
        
        Args:
            data (str): 要发送的数据
        """
        if self.connected and self._writer:
            try:
                # 三元表达式确保数据以换行符结尾（MUD命令通常需要）
                send_data = data if data.endswith('\n') else data + '\n'
                
                # 发送命令，使用telnetlib3的write方法
                self._writer.write(send_data)
                await self._writer.drain()
                
                # 记录发送的数据（如果数据量较大，可以只记录前100个字符）
                log_data = send_data if len(send_data) <= 100 else send_data[:100] + '...（截断）'
                self.logger.debug(f"发送数据: {repr(log_data)}")
                
            except Exception as e:
                self.logger.error(f"发送数据失败: {str(e)}", exc_info=True)
                await self.disconnect()
        else:
            self.logger.warning("无法发送数据：未连接到服务器")
    
    async def receive_data(self, encoding: str = 'utf-8', read_line=False) -> Optional[str]:
        """
        接收来自服务器的数据
        
        数据流处理规范的起始环节：
        由MUDClient调用，负责从网络接收服务器发来的数据并进行预处理
        
        Args:
            encoding (str): 接收数据使用的解码方式，默认为utf-8
            
        Returns:
            Optional[str]: 接收到的数据，如果连接断开则返回None
        """
        if not self.connected or not self._reader:
            return None
            
        try:
            # 从服务器读取数据
            data = await self._reader.readline() if read_line else await self._reader.read(1024)
            if not data:
                # 连接已断开
                self.logger.info("服务器连接已断开")
                await self.disconnect()
                return None
            
            # 记录接收到的原始数据（用于调试）
            self.logger.debug(f"接收数据: {repr(data)}")
            
            # 确保返回字符串类型数据，避免因类型错误导致系统崩溃
            if isinstance(data, str):
                # 如果已经是字符串，直接返回
                return remove_control_characters(data)
            elif isinstance(data, bytes):
                # 如果是字节数据，尝试解码
                try:
                    return data.decode(encoding)
                except UnicodeDecodeError:
                    # 如果指定编码解码失败，尝试使用latin1编码（不会出错）
                    return data.decode('latin1')
            else:
                # 如果是其他类型，转换为字符串
                return str(data)
            
        except Exception as e:
            self.logger.error(f"接收数据时发生错误: {e}")
            await self.disconnect()
            return None
